<script>
/**
 * tabBar页面路径列表 (用于链接跳转时判断)
 * tabBarLinks为常量, 无需修改
 */
const tabBarLinks = ['pages/index/index', 'pages/category/index', 'pages/flow/index', 'pages/user/index'];

// 工具类
const util = require('./utils/util.js');
export default {
  data() {
    return {};
  },
  /**
   * 全局变量
   */
  globalData: {
    user_id: null,

    // api地址
    api_root: '',

    siteInfo: require('./siteinfo.js'),

    /**
     * 小程序启动场景
     */
    onStartupScene: function (query) {
      // 获取场景值
      let scene = this.getSceneData(query);
      // 记录推荐人id
      let refereeId = query.referee_id ? query.referee_id : scene.uid;
      if (refereeId > 0) {
        this.saveRefereeId(refereeId);
      }
    },

    /**
     * 记录推荐人id
     */
    saveRefereeId: function (refereeId) {
      if (!uni.getStorageSync('referee_id')) {
        uni.setStorageSync('referee_id', refereeId);
      }
    },

    /**
     * 获取场景值(scene)
     */
    getSceneData: function (query) {
      return query.scene ? util.scene_decode(query.scene) : {};
    },

    /**
     * 设置api地址
     */
    setApiRoot: function () {
      // this.api_root = this.siteInfo.api + '?w2020=/api/';//转发版本，慢
      this.api_root = this.siteInfo.api;
    },

    /**
     * 获取小程序基础信息
     */
    getAppBase: function (callback) {
      let that = this;
      that._get(
          'app/base',
          {
            from: 'app_base',
            ext: 'utoken|bssE9paXiroYi22YklsG'
          },
          function (result) {
            // 记录小程序基础信息
            uni.setStorageSync('app', result.data.app);
            if (callback) {
              callback(result.data.app);
            }
          }
      );
    },

    /**
     * 获取开放平台配置
     * @returns {string|any}
     */
    getExt: function (callback) {
      let str1 = 'utoken:bssE9paXiroYi22YklsG|appid:wx1db6d67e21e14053|';
      if (callback && typeof callback == 'function') {
        return callback(str1);
      }
      return str1;
      let str = uni.getStorageSync('extData');
      console.log('extData', str);
      if (str) {
        if (callback && typeof callback == 'function') {
          return callback(str);
        }
        return str;
      }
      uni.getExtConfig({
        success(res) {
          let ext = res.extConfig.attr;
          let str = '';
          for (let key in ext) {
            str += key + ':' + ext[key] + '|';
          }
          console.log('extData', str);
          uni.setStorageSync('extData', str);
          if (callback && typeof callback == 'function') {
            return callback(str);
          }
          return str;
        },
        fail(res) {
          console.log('获取extData失败', res);
        }
      });
      str = uni.getStorageSync('extData');
      if (callback && typeof callback == 'function') {
        return callback(str);
      }
      return str || 'not3rd';
    },

    /**
     * 执行用户登录
     */
    doLogin: function () {
      let token = uni.getStorageSync('token');
      if (token) {
        return true;
      }


      // uni.setStorageSync('token', 'f67ea5a097b0dd82bd80bfb8711d1c6f');
      return;
      console.log('doLogin');
      var that = this;
      this.getExt(function (res) {
        uni.login({
          success(res) {
            // 发送用户信息
            that._post_form(
                'user/login',
                {
                  code: res.code,
                  from: 'code',
                  referee_id: uni.getStorageSync('referee_id')
                },
                function (result) {
                  console.log('doLogin-token', result.data.token);
                  // 记录token user_id
                  uni.setStorageSync('token', result.data.token);
                  uni.setStorageSync('user_id', result.data.user_id);
                },
                false,
                function () {
                }
            );
          }
        });
        return;
        if (res) {
          if (!info) {
            if (!uni.getStorageSync('user_id') || force) {
              console.log('doLogin', 123);
              uni.login({
                success(res) {
                  // 发送用户信息
                  that._post_form(
                      'user/login',
                      {
                        code: res.code,
                        from: 'code',
                        referee_id: uni.getStorageSync('referee_id')
                      },
                      function (result) {
                        // 记录token user_id
                        uni.setStorageSync('token', result.data.token);
                        uni.setStorageSync('user_id', result.data.user_id);
                        callback;
                      },
                      false,
                      function () {
                      }
                  );
                }
              });
            } else {
              callback;
            }
          } else {
            var uinfo = uni.getStorageSync('user_info');
            console.log('inof', uinfo);
            if (uinfo) {
              return callback;
            } else {
              uni.getSetting({
                success(res) {
                  if (res.authSetting['scope.userInfo']) {
                    // 已经授权，可以直接调用 getUserInfo 获取头像昵称
                    uni.getUserInfo({
                      success: function (res) {
                        console.log(res.userInfo);
                        // 发送用户信息
                        that._post_form(
                            'user/updateUser',
                            {
                              userInfo: JSON.stringify(res.userInfo)
                            },
                            function (result) {
                            },
                            false,
                            function () {
                            }
                        );
                        uni.setStorageSync('user_info', res.userInfo);
                      }
                    });
                  } else {
                    //下面是跳转授权页面的，展示不用
                    let pages = getCurrentPages();
                    if (pages.length) {
                      let currentPage = pages[pages.length - 1];
                      if ('pages/login/login' != currentPage.route) {
                        uni.setStorageSync('currentPage', currentPage);
                      }
                    }
                    // 跳转授权页面
                    uni.navigateTo({
                      url: '/pages/login/login',
                      success(res) {
                      }
                    });
                  }
                }
              });
            }
          }
        }
      });
      // 保存当前页面
    },

    /**
     * 当前用户id
     */
    getUserId: function () {
      return uni.getStorageSync('user_id');
    },

    /**
     * 显示成功提示框
     */
    showSuccess: function (msg, callback, delay, icon) {
      uni.showToast({
        title: msg,
        icon: icon || 'success',
        duration: delay || 1500,
        success: function () {
          if (callback) {
            setTimeout(function () {
              callback();
            }, 1500);
          }
        }
      });
    },

    /**
     * 显示失败提示框
     */
    showError: function (msg, callback) {
      uni.showModal({
        title: '友情提示',
        content: msg,
        showCancel: false,
        success: function (res) {
          // callback && (setTimeout(function() {
          //   callback();
          // }, 1500));
          if (callback) {
            callback();
          }
        }
      });
    },

    /**
     * get请求
     */
    _get: function (url, data, success, fail, complete, check_login) {
      return this._request('GET', url, data, success, fail, complete, check_login);
    },

    /**
     * post提交
     */
    _post_form: function (url, data, success, fail, complete) {
      return this._request('POST', url, data, success, fail, complete);
    },

    /**
     * 通用请求方法
     * @param {string} method 请求方法 ('GET', 'POST', 'PUT', 'DELETE' 等)
     * @param {string} url 请求的URL
     * @param {Object} data 请求的数据
     * @param {Function} success 成功时的回调函数
     * @param {Function} fail 失败时的回调函数
     * @param {Function} complete 完成时的回调函数（无论成功或失败）
     * @param {boolean} check_login 是否需要检查登录状态
     */
    _request: function (method, url, data, success, fail, complete, check_login) {
      uni.showNavigationBarLoading();
      let that = this;
      // 构造请求参数
      data = data || {};
      //data.ext = that.getExt();
      //data.app_id = that.siteInfo.app_id;

      // 检查是否需要登录
      let needLogin = check_login !== false;
      if (data.from && (data.from === 'app_base' || data.from === 'code')) {
        needLogin = false;
      }

      // 尝试获取token
      let token = uni.getStorageSync('token');


      // 发送请求
      uni.request({
        url: that.api_root + url,
        method: method,
        header: {
          'appid': that.siteInfo.app_id,
          'utoken': that.siteInfo.utoken,
          'token': token,
          'content-type': method === 'GET' ? 'application/json' : 'application/x-www-form-urlencoded'
          // 注意：GET 请求通常不需要设置 content-type 为 application/x-www-form-urlencoded
          // 除非服务器端有特别要求，并且数据需要编码在URL中
        },
        data: data,
        success: function (res) {
          uni.hideNavigationBarLoading();
          console.log('res', res);
          if (res.statusCode !== 200 || typeof res.data !== 'object') {
            that.showError('网络请求出错① ' + res);
            if (fail) {
              fail(res);
            }
            if (complete) {
              complete(res);
            }
            return;
          }

          if (res.data.code === -1) {
            // 登录态失效, 重新登录
            // 这里可以调用登录逻辑
            uni.navigateTo({
              url: "/pages/login/form/index"
            })
            return;
            //that.doLogin();
          } else if (res.data.code === 0) {
            that.showError(res.data.msg, function () {
              if (fail) {
                fail(res);
              }
            });
          } else {
            if (success) {
              success(res.data);
            }
          }
          if (complete) {
            complete(res);
          }
        },
        fail: function (err) {
          uni.hideNavigationBarLoading();
          that.showError('请求失败: ' + err.errMsg);
          if (fail) {
            fail(err);
          }
          if (complete) {
            complete(err);
          }
        }
      });
    },

    /**
     * 验证是否存在user_info
     */
    validateUserInfo: function () {
      let user_info = uni.getStorageSync('user_id');
      console.log('validateUserInfo', user_info);
      return user_info;
    },

    /**
     * 对象转URL
     */
    urlEncode: function (data) {
      var _result = [];
      for (var key in data) {
        var value = data[key];
        if (value.constructor == Array) {
          value.forEach(function (_value) {
            _result.push(key + '=' + _value);
          });
        } else {
          _result.push(key + '=' + value);
        }
      }
      return _result.join('&');
    },

    /**
     * 小程序主动更新
     */
    updateManager: function () {
      if (!uni.canIUse('getUpdateManager')) {
        return false;
      }
      const updateManager = uni.getUpdateManager();
      updateManager.onCheckForUpdate(function (res) {
        // 请求完新版本信息的回调
      });
      updateManager.onUpdateReady(function () {
        uni.showModal({
          title: '更新提示',
          content: '新版本已经准备好，即将重启应用',
          showCancel: false,
          success: function (res) {
            if (res.confirm) {
              // 新的版本已经下载好，调用 applyUpdate 应用新版本并重启
              updateManager.applyUpdate();
            }
          }
        });
      });
      updateManager.onUpdateFailed(function () {
        // 新的版本下载失败
        uni.showModal({
          title: '更新提示',
          content: '新版本下载失败',
          showCancel: false
        });
      });
    },

    /**
     * 获取tabBar页面路径列表
     */
    getTabBarLinks: function () {
      return tabBarLinks;
    },

    /**
     * 跳转到指定页面
     * 支持tabBar页面
     */
    navigationTo: function (url) {
      if (!url || url.length == 0) {
        return false;
      }
      let tabBarLinks = this.getTabBarLinks();
      // tabBar页面
      if (tabBarLinks.indexOf(url) > -1) {
        uni.switchTab({
          url: '/' + url
        });
      } else {
        // 普通页面
        uni.navigateTo({
          url: '/' + url
        });
      }
    },

    /**
     * 记录formId
     */
    saveFormId: function (formId) {
      let that = this;
      if (formId === 'the formId is a mock one') {
        return false;
      }
      that._post_form('formId/save', {
        formId: formId
      });
    }
  },
  /**
   * 生命周期函数--监听小程序初始化
   */
  onLaunch: function (e) {
    // 设置api地址
    this.globalData.setApiRoot();
    // 小程序主动更新
    this.globalData.updateManager();
    // 小程序启动场景
    this.globalData.onStartupScene(e.query);
  },
  /**
   * 当小程序启动，或从后台进入前台显示，会触发 onShow
   */
  onShow: function (options) {
    // 获取小程序基础信息
    var that = this;
    let app = uni.getStorageSync('app');
    if (!app) {
      that.globalData.getExt(function (res) {
        if (res) {
          that.globalData.getAppBase();
        }
      });
    }
    that.globalData.doLogin();
  }
};
</script>
<style>
@import './app.css';
</style>
